use crate::AppError;
use chrono::{DateTime, Utc};
use std::collections::HashMap;
use std::sync::Mutex;
use uuid::Uuid;

// 内存数据存储（实际项目中应该使用数据库）
lazy_static::lazy_static! {
    pub static ref DATA_STORE: Mutex<HashMap<String, Vec<serde_json::Value>>> = Mutex::new(HashMap::new());
}

pub struct Utils;

impl Utils {
    // 生成唯一ID
    pub fn generate_id() -> String {
        Uuid::new_v4().to_string()
    }

    // 格式化时间
    pub fn format_datetime(dt: &DateTime<Utc>) -> String {
        dt.format("%Y-%m-%d %H:%M:%S").to_string()
    }

    // 解析时间字符串
    pub fn parse_datetime(s: &str) -> Result<DateTime<Utc>, AppError> {
        chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")
            .map(|ndt| DateTime::from_naive_utc_and_offset(ndt, Utc))
            .map_err(|e| AppError::ValidationError(format!("时间格式错误: {}", e)))
    }

    // 分页处理
    pub fn paginate<T: Clone>(
        data: &[T],
        page: Option<i32>,
        size: Option<i32>,
    ) -> (Vec<T>, i64) {
        let page = page.unwrap_or(1).max(1);
        let size = size.unwrap_or(10).max(1);
        let total = data.len() as i64;
        
        let start = ((page - 1) * size) as usize;
        let end = (start + size as usize).min(data.len());
        
        let list = if start < data.len() {
            data[start..end].to_vec()
        } else {
            vec![]
        };
        
        (list, total)
    }

    // 搜索过滤
    pub fn filter_by_keyword<T: Clone + serde::Serialize>(
        data: &[T],
        keyword: &str,
    ) -> Vec<T> {
        if keyword.is_empty() {
            return data.to_vec();
        }

        data.iter()
            .filter(|item| {
                let json = serde_json::to_string(item).unwrap_or_default();
                json.to_lowercase().contains(&keyword.to_lowercase())
            })
            .cloned()
            .collect()
    }

    // 状态过滤
    pub fn filter_by_status<T: Clone + serde::Serialize>(
        data: &[T],
        status: &str,
    ) -> Vec<T> {
        if status.is_empty() {
            return data.to_vec();
        }

        data.iter()
            .filter(|item| {
                let json = serde_json::to_string(item).unwrap_or_default();
                json.contains(status)
            })
            .cloned()
            .collect()
    }

    // 时间范围过滤
    pub fn filter_by_time_range<T: Clone + serde::Serialize>(
        data: &[T],
        start_time: Option<DateTime<Utc>>,
        end_time: Option<DateTime<Utc>>,
    ) -> Vec<T> {
        data.iter()
            .filter(|item| {
                let json = serde_json::to_string(item).unwrap_or_default();
                
                // 这里简化处理，实际项目中应该解析JSON中的时间字段
                if let Some(start) = start_time {
                    if json.contains(&start.format("%Y-%m-%d").to_string()) {
                        return false;
                    }
                }
                
                if let Some(end) = end_time {
                    if json.contains(&end.format("%Y-%m-%d").to_string()) {
                        return false;
                    }
                }
                
                true
            })
            .cloned()
            .collect()
    }

    // 获取系统信息
    pub fn get_system_info() -> HashMap<String, String> {
        let mut info = HashMap::new();
        
        // 操作系统信息
        info.insert("os".to_string(), std::env::consts::OS.to_string());
        info.insert("arch".to_string(), std::env::consts::ARCH.to_string());
        
        // 应用信息
        info.insert("app_name".to_string(), "Tauri SIP 管理系统".to_string());
        info.insert("version".to_string(), env!("CARGO_PKG_VERSION").to_string());
        
        // 时间信息
        info.insert("current_time".to_string(), Utils::format_datetime(&Utc::now()));
        
        info
    }

    // 模拟系统统计
    pub fn get_system_stats() -> crate::SystemStats {
        use rand::Rng;
        let mut rng = rand::thread_rng();
        
        crate::SystemStats {
            cpu_usage: rng.gen_range(10.0..80.0),
            memory_usage: rng.gen_range(20.0..90.0),
            disk_usage: rng.gen_range(30.0..85.0),
            network_in: rng.gen_range(100.0..1000.0),
            network_out: rng.gen_range(50.0..500.0),
        }
    }

    // 验证手机号格式
    pub fn validate_phone(phone: &str) -> bool {
        let phone_regex = regex::Regex::new(r"^1[3-9]\d{9}$").unwrap();
        phone_regex.is_match(phone)
    }

    // 验证邮箱格式
    pub fn validate_email(email: &str) -> bool {
        let email_regex = regex::Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
        email_regex.is_match(email)
    }

    // 生成随机字符串
    pub fn generate_random_string(length: usize) -> String {
        use rand::Rng;
        let mut rng = rand::thread_rng();
        const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        
        (0..length)
            .map(|_| {
                let idx = rng.gen_range(0..CHARSET.len());
                CHARSET[idx] as char
            })
            .collect()
    }
}
